use std::{collections::HashMap, sync::Arc, vec};
use std::path::{Path};
use async_trait::async_trait;
use extension_base_schema::ProjectStructureFactory;
use extension_djgc::DjgcFactory;
use extension_fbfx_csxm::FbfxCsxmFactory;
use extension_rcj::RcjFactory;
use mf_core::{
    Extension,
    config::ForgeConfig,
    event::{Event, EventHandler},
    middleware::MiddlewareStack,
    types::Extensions,
};
use mf_persistence::api::{CommitMode, PersistOptions};
use mf_persistence::sqlite::SqliteEventStore;
use mf_persistence::subscriber::SnapshotSubscriber;
use price_common::{BootstrapError, ProjectPhase};
use price_common::bootstrap::{
    BootstrapContext, BootstrapRegistry, BootstrapResult, DataSourceProvider, EventHandlerProvider, ExtensionProvider, ForgeConfigProvider,
    MetadataProvider, MiddlewareProvider, ProjectProfile, ProviderSelector, RuleProvider,
};
use price_rules::loader::RulesLoaderExt;
use price_rules::loader::sys_loader::SystemLoader;
use crate::search::create_search_index_handler;



/// 默认的 Schema 提供器
///
/// 提供空的 schema 扩展，适用于不需要自定义节点的场景
pub struct DefaultSchemaProvider;

#[async_trait]
impl ExtensionProvider for DefaultSchemaProvider {
    async fn provide(
        &self,
        profile: &ProjectProfile,
    ) -> BootstrapResult<Vec<Extensions>> {
        let mut extensions = Vec::new();
        match profile.phase {
            //预算项目
            ProjectPhase::Budget => {
                //添加节点定义
                //1: 左侧 工程项目树
                let base_schema_def = ProjectStructureFactory::build();
                extensions.extend(base_schema_def);
                //2: 分部分项措施项目
                let fbfx_csxm_def = FbfxCsxmFactory::build();
                extensions.extend(fbfx_csxm_def);
                //3: 单价构成
                let djgc_def = DjgcFactory::build();
                extensions.extend(djgc_def);
                //4：人材机
                let fcj_def = RcjFactory::build();
                extensions.extend(fcj_def);
                //5: 标准换算
                //6：费用汇总
                // 除了组件外 项目自身定义 关系依赖
                let mut ext_ = Extension::new();
                ext_.add_node_transform(Arc::new(|_node_def| {
                    //在这里进行组装 修改节点的默认行为

                    Ok(())
                }));
                extensions.push(Extensions::E(ext_));
            },
            _ => {},
        }
        Ok(extensions)
    }

    fn name(&self) -> &'static str {
        "default_schema_provider"
    }
}

/// 默认的数据源提供器
/// 指定项目需要的 数据源  可以是db 或者是http 请求 或者其他
/// 不配置任何数据源，适用于不需要外部数据源的场景
pub struct DefaultDataSourceProvider;

#[async_trait]
impl DataSourceProvider for DefaultDataSourceProvider {
    async fn configure(
        &self,
        profile: &ProjectProfile,
        _ctx: &mut BootstrapContext,
    ) -> BootstrapResult<()> {
        //不同的 项目加载的数据源不同
        //预算添加预算的
        match profile.phase {
            ProjectPhase::Budget => {},
            _ => {},
        }

        Ok(())
    }

    fn name(&self) -> &'static str {
        "default_data_source_provider"
    }
}

/// 默认的元数据提供器
///
/// 提供空的元数据，适用于不需要额外元数据的场景
pub struct DefaultMetadataProvider;

#[async_trait]
impl MetadataProvider for DefaultMetadataProvider {
    async fn provide(
        &self,
        profile: &ProjectProfile,
    ) -> BootstrapResult<HashMap<String, String>> {
        //配置项目的元数据
        match profile.phase {
            ProjectPhase::Budget => {},
            _ => {},
        }
        Ok(HashMap::new())
    }

    fn name(&self) -> &'static str {
        "default_metadata_provider"
    }
}

/// 默认的事件处理器提供器
/// 日志记录或者 自定义业务逻辑触发器 比如协作同步
/// 提供空的事件处理器列表，适用于不需要事件处理的场景。
/// 如果需要添加日志、监控、审计等功能，可以实现自定义的 EventHandlerProvider。
pub struct DefaultEventHandlerProvider;

#[async_trait]
impl EventHandlerProvider for DefaultEventHandlerProvider {
    async fn provide(
        &self,
        profile: &ProjectProfile,
    ) -> BootstrapResult<Vec<Arc<dyn EventHandler<Event> + Send + Sync>>> {
        let mut handles:Vec<Arc<dyn EventHandler<Event> + Send + Sync>> =vec![];
        // 默认不提供任何事件处理器 异步执行
        // 用户可以根据需要添加：
        // - 日志记录器
        // - 性能监控器
        // - 审计追踪器
        // - 自定义业务逻辑触发器
        match profile.phase {
            ProjectPhase::Budget => {
                let path = Path::new(&profile.project_id);
                //----------------------------初始化快照处理器-----------------------------------------------
                let store = SqliteEventStore::open(
                    path,
                    CommitMode::AsyncDurable { group_window_ms: 8 },
                )
                    .await.map_err(|e|BootstrapError::provider_failure("persistence 初始化失败",e))?;

                // 2) 配置持久化选项（定期快照）
                let persist_opts = PersistOptions {
                    commit_mode: CommitMode::AsyncDurable { group_window_ms: 8 },
                    snapshot_every_n_events: 1000,
                    snapshot_every_bytes: 8 * 1024 * 1024,
                    snapshot_every_ms: 5 * 60 * 1000,
                    compression: true,
                };

                // 3) 注入持久化订阅者（由事件驱动持久化与快照）
                let subscriber = Arc::new(SnapshotSubscriber::new(
                    store,
                    persist_opts,
                    "default_doc",
                ));
                handles.push(subscriber);
                //--------------------------------- 初始化本地搜索 引擎------------------------------------------

               let ser = create_search_index_handler(path).await.map_err(|e|BootstrapError::InvalidConfiguration(e.to_string()))?;
                handles.push(ser);
            },
            _ => {},
        }
        Ok(handles)
    }

    fn name(&self) -> &'static str {
        "default_event_handler_provider"
    }
}

/// 默认的中间件提供器
/// 统一前置拦截后置处理
/// 提供空的中间件栈，适用于不需要中间件的场景。
/// 如果需要添加请求拦截、权限验证、数据转换等功能，可以实现自定义的 MiddlewareProvider。
pub struct DefaultMiddlewareProvider;

#[async_trait]
impl MiddlewareProvider for DefaultMiddlewareProvider {
    async fn provide(
        &self,
        profile: &ProjectProfile,
    ) -> BootstrapResult<MiddlewareStack> {
        // 默认提供空的中间件栈 顺序执行 先加入的先执行
        // 用户可以根据需要添加：
        // - 请求/响应拦截器
        // - 权限验证中间件
        // - 数据转换中间件
        // - 缓存处理中间件
        match profile.phase {
            ProjectPhase::Budget => {},
            _ => {},
        }
        Ok(MiddlewareStack::new())
    }

    fn name(&self) -> &'static str {
        "default_middleware_provider"
    }
}

/// 默认的 Forge 配置提供器
///
/// 根据项目阶段提供不同的性能配置：
/// - 开发阶段：启用详细日志和监控
/// - 测试阶段：平衡性能和监控
/// - 生产阶段：优化性能，减少监控开销
pub struct DefaultForgeConfigProvider;

#[async_trait]
impl ForgeConfigProvider for DefaultForgeConfigProvider {
    async fn provide(
        &self,
        profile: &ProjectProfile,
    ) -> BootstrapResult<ForgeConfig> {
        // 根据项目阶段选择合适的配置
        // Budget(预算) -> Development 环境
        // Settlement(结算) -> Testing 环境
        // Audit(审核) -> Production 环境
        let config = match profile.phase {
            _ => ForgeConfig::default(),
        };

        Ok(config)
    }

    fn name(&self) -> &'static str {
        "default_forge_config_provider"
    }
}



/// 规则提供器返回上述加载器
struct DefaultRuleProvider;

#[async_trait]
impl RuleProvider for DefaultRuleProvider {
    async fn provide(
        &self,
        profile: &ProjectProfile,
    ) -> BootstrapResult<Arc<dyn RulesLoaderExt>> {
        match profile.metadata.get("rules") {
            None => {
              Err(BootstrapError::InvalidConfiguration("profile.metadata 缺少规则引擎路径配置".to_string()))
            }
            Some(rules) => {
                Ok(Arc::new(SystemLoader{ root: rules.clone() }))
            }
        }

    }

    fn name(&self) -> &'static str {
        "test-rule"
    }
}


/// 创建默认的 Bootstrap 注册表
///
/// 注册所有默认的 Provider，适用于快速启动和测试场景。
///
/// # 参数
/// * `rule_provider` - 规则提供器（必须提供，因为规则是业务核心）
///
/// # 返回
/// 配置好的 `BootstrapRegistry` 实例
///
/// # 示例
/// ```rust
/// use price_budget_core::bootstrap::create_default_registry;
/// use price_rules::loader::RulesLoaderExt;
/// use std::sync::Arc;
///
/// // 创建规则提供器
/// struct MyRuleProvider {
///     loader: Arc<dyn RulesLoaderExt>,
/// }
///
/// #[async_trait]
/// impl RuleProvider for MyRuleProvider {
///     async fn provide(&self, _profile: &ProjectProfile) -> BootstrapResult<Arc<dyn RulesLoaderExt>> {
///         Ok(self.loader.clone())
///     }
/// }
///
/// // 创建默认注册表
/// let rule_provider = MyRuleProvider { loader: my_loader };
/// let registry = create_default_registry(rule_provider);
/// ```
pub fn create_default_registry<R>(rule_provider: R) -> BootstrapRegistry
where
    R: RuleProvider + 'static,
{
    let mut registry = BootstrapRegistry::new();

    // 使用通配符选择器，匹配所有项目和阶段
    let selector = ProviderSelector::default();

    // 注册所有默认 Provider
    registry.register_schema(selector.clone(), DefaultSchemaProvider);
    registry.register_data_source(selector.clone(), DefaultDataSourceProvider);
    registry.register_metadata(selector.clone(), DefaultMetadataProvider);
    registry.register_event_handler(selector.clone(), DefaultEventHandlerProvider);
    registry.register_middleware(selector.clone(), DefaultMiddlewareProvider);
    registry.register_forge_config(selector.clone(), DefaultForgeConfigProvider);
    registry.register_rule(selector, rule_provider);

    registry
}
///
/// ### 描述：
///-  DefaultSchemaProvider:预算项目中所有的节点 标记定义和 扩展定义的加载，并且 预算项目独有的融合包装
///-  DefaultDataSourceProvider: 第三方的数据源 配置 比如: http 请求 sqlite db 或者mysql链接
///-  DefaultMetadataProvider：元数据 启动时候的元数据
///-  DefaultEventHandlerProvider：预算需要的 事件处理器 比如：快照处理器 搜索引擎处理器
///-  DefaultMiddlewareProvider：拦截器配置 前后置处理器 比如：日志处理  记取 费用汇总 一般都在后置处理
///-  DefaultForgeConfigProvider：启动运行时配置 ForgeConfig 具体参考文档
///-  DefaultRulesLoader：规则引擎处理器 项目中如何加载 规则 默认处理从 文件加载 可自定义实现 从 db 中获取 比如 sqlite
///
/// 创建自定义的 Bootstrap 注册表构建器
///
/// 提供链式 API 来自定义各个 Provider，同时保留默认实现。
///
/// # 示例
/// ```rust
/// use price_budget_core::bootstrap::BootstrapRegistryBuilder;
///
/// let registry = BootstrapRegistryBuilder::new()
///     .with_rule_provider(my_rule_provider)
///     .with_schema_provider(my_schema_provider)  // 可选：覆盖默认
///     .with_forge_config_provider(my_config_provider)  // 可选：覆盖默认
///     .build();
/// ```
pub struct BootstrapRegistryBuilder {
    registry: BootstrapRegistry,
    selector: ProviderSelector,
}

impl BootstrapRegistryBuilder {
    /// 创建新的构建器
    pub fn new() -> Self {
        Self { registry: BootstrapRegistry::new(), selector: ProviderSelector::default() }
    }

    /// 设置选择器（用于筛选 Provider）
    pub fn with_selector(
        mut self,
        selector: ProviderSelector,
    ) -> Self {
        self.selector = selector;
        self
    }

    /// 设置规则提供器（必需）
    pub fn with_rule_provider<R>(
        mut self,
        provider: R,
    ) -> Self
    where
        R: RuleProvider + 'static,
    {
        self.registry.register_rule(self.selector.clone(), provider);
        self
    }

    /// 设置 Schema 提供器（可选，默认为空）
    pub fn with_schema_provider<P>(
        mut self,
        provider: P,
    ) -> Self
    where
        P: ExtensionProvider + 'static,
    {
        self.registry.register_schema(self.selector.clone(), provider);
        self
    }

    /// 设置数据源提供器（可选，默认为空）
    pub fn with_data_source_provider<P>(
        mut self,
        provider: P,
    ) -> Self
    where
        P: DataSourceProvider + 'static,
    {
        self.registry.register_data_source(self.selector.clone(), provider);
        self
    }

    /// 设置元数据提供器（可选，默认为空）
    pub fn with_metadata_provider<P>(
        mut self,
        provider: P,
    ) -> Self
    where
        P: MetadataProvider + 'static,
    {
        self.registry.register_metadata(self.selector.clone(), provider);
        self
    }

    /// 设置事件处理器提供器（可选，默认为空）
    pub fn with_event_handler_provider<P>(
        mut self,
        provider: P,
    ) -> Self
    where
        P: EventHandlerProvider + 'static,
    {
        self.registry.register_event_handler(self.selector.clone(), provider);
        self
    }

    /// 设置中间件提供器（可选，默认为空）
    pub fn with_middleware_provider<P>(
        mut self,
        provider: P,
    ) -> Self
    where
        P: MiddlewareProvider + 'static,
    {
        self.registry.register_middleware(self.selector.clone(), provider);
        self
    }

    /// 设置 Forge 配置提供器（可选，默认根据阶段自动配置）
    pub fn with_forge_config_provider<P>(
        mut self,
        provider: P,
    ) -> Self
    where
        P: ForgeConfigProvider + 'static,
    {
        self.registry.register_forge_config(self.selector.clone(), provider);
        self
    }

    /// 构建注册表
    ///
    /// # Panics
    /// 如果没有设置规则提供器，将会 panic
    pub fn build(mut self) -> BootstrapRegistry {
        // 如果没有设置其他 Provider，使用默认实现
        self.fill_defaults();

        self.registry
    }

    /// 填充默认的 Provider（如果用户没有自定义）
    fn fill_defaults(&mut self) {
        // 注意：这里我们不能检查是否已经注册，因为 BootstrapRegistry 没有提供查询接口
        // 所以我们采用"总是注册默认值"的策略，用户自定义的会优先匹配

        // 使用更低优先级的选择器注册默认值
        let default_selector = ProviderSelector::default();
         //注册扩展
        self.registry.register_schema(default_selector.clone(), DefaultSchemaProvider);
        //注册数据源
        self.registry.register_data_source(default_selector.clone(), DefaultDataSourceProvider);
        //注册元数据
        self.registry.register_metadata(default_selector.clone(), DefaultMetadataProvider);
        //注册事件处理器
        self.registry.register_event_handler(default_selector.clone(), DefaultEventHandlerProvider);
        //注册中间件
        self.registry.register_middleware(default_selector.clone(), DefaultMiddlewareProvider);
        //注册运行时配置
        self.registry.register_forge_config(default_selector.clone(), DefaultForgeConfigProvider);
        //注册规则引擎配置
        self.registry.register_rule(default_selector, DefaultRuleProvider);

    }
}

impl Default for BootstrapRegistryBuilder {
    fn default() -> Self {
        Self::new()
    }
}
